home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / BEERSRC.ZIP / MENU.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-26  |  12.4 KB  |  518 lines
  1. #pragma hdrstop
  2.  
  3. #include <sys\stat.h>
  4. #include <dos.h>
  5. #include <fcntl.h>
  6. #include <io.h>
  7. #include <alloc.h>
  8. #include <stdlib.h>
  9.  
  10. #define MENUX           142     // X-offset for first menupoint
  11. #define MENUY           58      // Y-offset for first menupoint
  12. #define MSTEP           3       // How far to move at once
  13. #define MENUDELTA       9/MSTEP // 1/MSTEP distance between menupoints
  14. #define MENXTXT        160    // X-offset for menutext sprite
  15. #define MENYTXT        46    // Y-offset for menutext sprite
  16. #define MENYTEXT    60    // Y-offset for menutext
  17. #define MENXTEXT    159    // X-offset for menutext
  18. #define MENYERR         99
  19.  
  20. #define ENDLOGOX        20
  21. #define ENDLOGOY        110
  22.  
  23. #define CREDITDELAY        100
  24. #define CREDITSPEED        2
  25. #define STORYSPEED        2
  26. #define BACKDELAY        502
  27. #define TITLEDELAY        460
  28.  
  29. #include "xmode.h"
  30. #include "sound.h"
  31. #include "fileman.h"
  32. #include "baller.h"
  33.  
  34. const int ownkeycodes[89] = {0,0,53,54,55,56,57,58,59,60,61,52,49,47,3,4,
  35.                  85,91,73,86,88,93,89,77,83,84,95,97,7,8,
  36.                  69,87,72,74,75,76,78,79,80,63,38,43,12,96,
  37.                  94,92,71,90,70,82,81,48,50,51,13,14,15,1,2,
  38.                  24,25,26,27,28,29,30,31,32,33,5,6,9,10,11,36,16,
  39.                  17,18,37,19,20,21,22,23,0,0,96,34,35};
  40.  
  41. const char keytable[38][7]={"ESC","SPACE","CPSLCK","BKSP","TAB","NUMLCK",
  42.                 "SCRLCK","ENTER","CTRL","HOME","UP","PGUP",
  43.                 "LSHFT","RSHFT","[*]","ALT","LEFT","[5]",
  44.                 "RIGHT","END","DOWN","PGDN","INSERT","DELETE",
  45.                 "F1","F2","F3","F4","F5","F6","F7","F8","F9",
  46.                 "F10","F11","F12","[-]","[+]"};
  47.  
  48. void loadconfig(void)
  49. {
  50.    int filvar;
  51.    int sound;
  52.  
  53.    if ((filvar = open("CONFIG.HIG", O_RDONLY | O_BINARY, S_IREAD)) == -1) {
  54.       key_up = KEYUP;
  55.       key_down = KEYDOWN;
  56.       key_left = KEYLEFT;
  57.       key_right = KEYRIGHT;
  58.       key_fire = KEYSPACE;
  59.       key_pause = KEYPAUSE;
  60.       return;
  61.    }
  62.    read(filvar, &key_up, sizeof(int));
  63.    read(filvar, &key_down, sizeof(int));
  64.    read(filvar, &key_left, sizeof(int));
  65.    read(filvar, &key_right, sizeof(int));
  66.    read(filvar, &key_fire, sizeof(int));
  67.    read(filvar, &key_pause, sizeof(int));
  68.    read(filvar, &sound, sizeof(int));
  69.    speaker(sound);
  70.    loadhighscore(&filvar);
  71.    close(filvar);
  72. }
  73.  
  74. void saveconfig(void)
  75. {
  76.    int filvar;
  77.    int sound;
  78.  
  79.    filvar = open("CONFIG.HIG", O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, S_IWRITE);
  80.    if (filvar == -1) return;
  81.    write(filvar, &key_up, sizeof(int));
  82.    write(filvar, &key_down, sizeof(int));
  83.    write(filvar, &key_left, sizeof(int));
  84.    write(filvar, &key_right, sizeof(int));
  85.    write(filvar, &key_fire, sizeof(int));
  86.    write(filvar, &key_pause, sizeof(int));
  87.    sound = speaker(-1);
  88.    write(filvar, &sound, sizeof(int));
  89.    savehighscore(&filvar);
  90.    close(filvar);
  91. }
  92.  
  93. static void closingtime(void)
  94. {
  95.    struct sprstrc *logo;
  96.    struct sndstrc *snd;
  97.  
  98.    while(pressedkeys);
  99.    clearscreen();
  100.    logo = loadfile(datapool, "close.spr");
  101.    snd  = loadfile(datapool, "close.snd");
  102.    playsample(snd);
  103.    putspritedirect(logo, ENDLOGOX, ENDLOGOY, 0);
  104.    glowin(0);
  105.  
  106.    while(!pressedkeys && soundbusy());
  107.  
  108.    glowout();
  109.    haltsound();
  110.    unloadfile(snd);
  111.    unloadfile(logo);
  112.    clearscreen();
  113.    setstandardpalette();
  114. }
  115.  
  116. static void credits(void)
  117. {
  118.    void  *ptr;
  119.    int   d, line, i;
  120.  
  121.    snd_cli();
  122.    ptr = loadfile(datapool, "credit.pcx");
  123.    glowout();
  124.    setpage(0);
  125.    clearscreen();
  126.    showpcx256(ptr, 0);
  127.    unloadfile(ptr);
  128.    showpage(0);
  129.    glowin(1);
  130.    snd_sti();                           // Make it visible.
  131.  
  132.    d = CREDITSPEED;            // Direction and speed of movement.
  133.    line = 0;
  134.    i = 0;
  135.    if(!waitdelayedkey(CREDITDELAY)){
  136.       snd_cli();
  137.       do {
  138.      showline(line);
  139.      line += d;
  140.      if (line < 0) {
  141.         i++;
  142.         d = -d; line += 2*d;
  143.         snd_sti();
  144.         if (waitdelayedkey(CREDITDELAY)) break;
  145.         snd_cli();
  146.      }
  147.      // 204 ist die linie, bei der das scrolling umgekehrt wird.
  148.      // Es ist ein proebli wert, der sehr stark vom kunstlerischen
  149.      // koennen des grafikers abhaengt.
  150.      if (line > 204) {
  151.         d = -d; line += 2*d;
  152.         snd_sti();
  153.         if (waitdelayedkey(CREDITDELAY)) break;
  154.         snd_cli();
  155.      }
  156.       } while (i!=2 && !pressedkeys);
  157.    }
  158. }
  159.  
  160.  
  161. static void showtitle(void)
  162. {
  163.    void  *ptr;
  164.    int filvar;
  165.    void far *buffer;
  166.  
  167.    setpage(0);
  168.    showpage(0);
  169.    setvanillapalette(0);
  170.    clearscreen();
  171.    ptr = loadfile(datapool, "back.pcx");
  172.    showpcx256(ptr, 0);
  173.    unloadfile(ptr);
  174.    ptr = loadfile(datapool, "title.pcx");
  175.    setpage(1);
  176.    showpcx256(ptr, 10);
  177.    unloadfile(ptr);
  178.    buffer = farmalloc(120*1024L);
  179.    filvar = openfile(datapool, "title.snd");
  180.    playfile(filvar, buffer, 120);
  181.    snd_cli();
  182.    glowin(0);
  183.    snd_sti();
  184.    waitdelayedkey(BACKDELAY);
  185.    snd_cli();
  186.    glowout();
  187.    showpage(1);
  188.    glowin(0);
  189.    snd_sti();
  190.    if (!waitdelayedkey(TITLEDELAY)) {
  191.       credits();
  192.    }
  193.    snd_cli();
  194.    glowout();
  195.    snd_sti();
  196.    haltsound();
  197.    closefile(filvar);
  198.    farfree(buffer);
  199. }
  200.  
  201. static int initmenu(struct sndstrc **s, int *pobj, int *pspr, struct sprstrc **mspr)
  202. {
  203.    void  *ptr;
  204.  
  205. // Load Menu, show and unload it
  206.  
  207.    clearscreen();
  208.    setpage(0);
  209.    ptr = loadfile(datapool, "menu.pcx");
  210.    showpcx256(ptr, 10);
  211.    copypage(0,1);
  212.    unloadfile(ptr);
  213.  
  214. // Load Pointer and place it
  215.  
  216.    ptr = loadfile(datapool, "mencur.spr");
  217.    *pspr = defsprite(ptr, 2);
  218.    unloadfile(ptr);
  219.    *pobj = defobject(*pspr, MENUX, MENUY, OBJ_LOW);
  220.  
  221. // Load Menutext sprite and put it
  222.  
  223.    *mspr = loadfile(datapool, "mentxt.spr");
  224.    putspritedirect(*mspr, MENXTXT, MENYTXT, 0);
  225.  
  226. // Load Sound, play it and display all
  227.  
  228.    *s = loadfile(datapool, "menu.snd");
  229.    playsample(*s);
  230.  
  231.    waitfortick();
  232.    updatescreen();
  233.    glowin(0);
  234.  
  235.    return 1;  // first menupoint is selected
  236. }
  237.  
  238. static void endmenu(struct sndstrc *snd, int pobj, int pspr, struct sprstrc *mspr)
  239. {
  240.    glowout();
  241.    killobject(pobj);
  242.    killsprite(pspr);
  243.    unloadfile(mspr);
  244.    haltsound();
  245.    unloadfile(snd);
  246. }
  247.  
  248. static int newkey(int y, const char *s, struct sprstrc *f1)
  249. {
  250.    int keys,k;
  251.  
  252.    while(pressedkeys);
  253.    writetext(MENXTXT,y,s,f1);
  254.    while(!pressedkeys);
  255.    keys = 0;
  256.    do{
  257.       keys++;
  258.    }while(key[keys] == 0);
  259.    k = ownkeycodes[keys];
  260.    if(k > 37) putspritedirect(f1, MENXTXT+40, y, k-36);
  261.    else writetext(MENXTXT+40,y,&keytable[k][0],f1);
  262.    return keys;
  263. }
  264.  
  265. static void defkeys(struct sprstrc *font1)
  266. {
  267.  
  268. // Left
  269.  
  270.    key_left = newkey(MENYTEXT-7, "LEFT", font1);
  271.  
  272. // Right
  273.  
  274.    key_right = newkey(MENYTEXT+3, "RIGHT", font1);
  275.  
  276. // Up
  277.  
  278.    key_up = newkey(MENYTEXT+13, "UP", font1);
  279.  
  280. // Down
  281.  
  282.    key_down = newkey(MENYTEXT+23, "DOWN", font1);
  283.  
  284. // Fire
  285.  
  286.    key_fire = newkey(MENYTEXT+33, "FIRE", font1);
  287.  
  288. // Pause
  289.  
  290.    key_pause = newkey(MENYTEXT+43, "PAUSE", font1);
  291.  
  292.    waitforkey();
  293.    saveconfig();
  294. }
  295.  
  296. static int showoptions(struct sprstrc *ofont, struct sprstrc *mspr)
  297. {
  298.    putspritedirect(mspr, MENXTXT, MENYTXT, 1);    // Clear mentxt
  299.  
  300.    writetext(MENXTEXT, MENYTEXT-8, "OPTIONS", ofont);
  301.    if(speaker(-1)) writetext(MENXTEXT, MENYTEXT+3, "1 SOUND ON", ofont);
  302.    else writetext(MENXTEXT, MENYTEXT+3, "1 SOUND OFF", ofont);
  303.    writetext(MENXTEXT, MENYTEXT+MSTEP*MENUDELTA+3, "2 CHOOSE KEYS", ofont);
  304.    writetext(MENXTEXT, MENYTEXT+MSTEP*MENUDELTA*2+3, "3 MAINMENU", ofont);
  305.    return 1;
  306. }
  307.  
  308. static int options(struct sndstrc *snd, int *pobj, int pspr, struct sprstrc *mspr)
  309. {
  310.    struct sprstrc *ofont;
  311.    int    quit, selected;
  312.    int i;
  313.  
  314.    haltsound();
  315.  
  316.    ofont = loadfile(datapool, "ofont.spr");
  317.  
  318. // Clear old menu and write new one
  319.  
  320.    selected = showoptions(ofont, mspr);
  321.    moveobject(*pobj, MENUX, MENUY+7);
  322.  
  323.    quit = FALSE;
  324.  
  325. // The Selection starts
  326.  
  327.    do{
  328.       while (pressedkeys) {
  329.      waitfortick();
  330.      updatescreen();
  331.       }
  332.       while (!pressedkeys) {
  333.      waitfortick();
  334.      updatescreen();
  335.       }
  336.       if(key[KEYONE] || (selected==1 && key[key_fire])){   // Sound on/off
  337.      if(speaker(-1)){     // Turn Sound off
  338.         writetext(MENXTEXT, MENYTEXT+3, "1 SOUND OFF", ofont);
  339.         speaker(0);
  340.         saveconfig();
  341.      }else{            // Turn Sound on
  342.         if(speaker(1)){
  343.            writetext(MENXTEXT, MENYTEXT+3, "1 SOUND ON ", ofont);
  344.            saveconfig();
  345.         }else{
  346.            writetext(MENXTEXT, MENYERR, "SOUNDBLASTER", ofont);
  347.            writetext(MENXTEXT, MENYERR+ofont->ys+1, " NOT FOUND", ofont);
  348.         }
  349.      }
  350.       }
  351.       if(key[KEYTWO] || (selected==2 && key[key_fire])){   // Redefine Keys
  352.      killobject(*pobj);
  353.      putspritedirect(mspr, MENXTXT, MENYTXT, 1);        // Clear mentxt
  354.      defkeys(ofont);
  355.      selected = showoptions(ofont, mspr);
  356.      *pobj = defobject(pspr, MENUX, MENUY+7, OBJ_LOW);
  357.       }
  358.       if(key[KEYTHREE] || (selected==3 && key[key_fire])){ // Quit Options
  359.      quit = TRUE;
  360.       }
  361.       if(key[key_up] && selected>1){                       // Up
  362.      for (i = 0; i < MENUDELTA; i++) {
  363.         moveobjectdelta(*pobj, 0, -MSTEP);
  364.         waitfortick();
  365.         updatescreen();
  366.      }
  367.      selected--;
  368.       }
  369.       if(key[key_down] && selected<3){                     // Down
  370.      if(selected == 1){
  371.         writetext(MENXTEXT, MENYERR, "            ", ofont);
  372.         writetext(MENXTEXT, MENYERR+ofont->ys+1, "          ", ofont);
  373.      }
  374.      for (i = 0; i < MENUDELTA; i++) {
  375.         moveobjectdelta(*pobj, 0, MSTEP);
  376.         waitfortick();
  377.         updatescreen();
  378.      }
  379.      selected++;
  380.       }
  381.    }while(!quit);
  382.  
  383. // Restore mainmenu
  384.  
  385.    playsample(snd);
  386.    putspritedirect(mspr, MENXTXT, MENYTXT, 0);
  387.    moveobject(*pobj, MENUX, MENUY);
  388.    waitfortick();
  389.    updatescreen();
  390.  
  391.    unloadfile(ofont);
  392.  
  393.    return 1;  // first menupoint is selected
  394. }
  395.  
  396. static void story(void)
  397. {
  398.    void *ptr;
  399.    void *sound;
  400.    int d, line;
  401.  
  402.    clearscreen();
  403.    setpage(0);
  404.    ptr = loadfile(datapool, "longtime.pcx");
  405.    showpcx256(ptr,0);
  406.    unloadfile(ptr);
  407.  
  408.    sound = loadfile(datapool, "longtime.snd");
  409.    playloop(sound);
  410.  
  411.    showpage(0);
  412.    snd_cli();
  413.    glowin(0);
  414.    snd_sti();
  415.  
  416.    d = CREDITSPEED;            // Direction and speed of movement.
  417.    line = 0;                 // Starting at line 0.
  418.    while(!pressedkeys);
  419.    snd_cli();
  420.    do {
  421.       showline(line);
  422.       line += d;
  423.    } while (line < 198);
  424.  
  425.    snd_sti();
  426.    while(!pressedkeys);
  427.  
  428.    // Stop sound and free memory
  429.    snd_cli();
  430.    glowout();
  431.    snd_sti();
  432.    haltsound();
  433.    unloadfile(sound);
  434. }
  435.  
  436.  //----------------//
  437. //      Menu        //
  438.  //----------------//
  439.  
  440. void menu(void)
  441. {
  442.    int    quit, selected, i;
  443.    int    pointobj, pointspr;
  444.    struct sprstrc *menuspr;
  445.    struct sndstrc *snd;
  446.    int    c;
  447.  
  448.  
  449.    showtitle();
  450.  
  451.    quit = FALSE;
  452.    selected = initmenu(&snd, &pointobj, &pointspr, &menuspr);
  453.    c = 0;
  454.    do{
  455.       while (pressedkeys) {
  456.      c = cyclepalette(232, 254, c);
  457.      waitfortick();
  458.      updatescreen();
  459.       }
  460.       while (!pressedkeys) {
  461.      c = cyclepalette(232, 254, c);
  462.      waitfortick();
  463.      updatescreen();
  464.       }
  465.       if(key[KEYONE] || (selected==1 && key[key_fire])){   // Play
  466.      endmenu(snd, pointobj, pointspr, menuspr);
  467.      clearscreen();
  468.      setstandardpalette();
  469.      playthegame();
  470.      selected = initmenu(&snd, &pointobj, &pointspr, &menuspr);
  471.       }
  472.       if(key[KEYTWO] || (selected==2 && key[key_fire])){   // Show Highscore
  473.      endmenu(snd, pointobj, pointspr, menuspr);
  474.      highscore(FALSE);
  475.      selected = initmenu(&snd, &pointobj, &pointspr, &menuspr);
  476.       }
  477.       if(key[KEYTHREE] || (selected==3 && key[key_fire])){ // Show Title
  478.      endmenu(snd, pointobj, pointspr, menuspr);
  479.      showtitle();
  480.      selected = initmenu(&snd, &pointobj, &pointspr, &menuspr);
  481.       }
  482.       if(key[KEYFOUR] || (selected==4 && key[key_fire])){  // Story
  483.      endmenu(snd, pointobj, pointspr, menuspr);
  484.      story();
  485.      selected = initmenu(&snd, &pointobj, &pointspr, &menuspr);
  486.       }
  487.       if(key[KEYFIVE] || (selected==5 && key[key_fire])){  // Options
  488.      selected = options(snd, &pointobj, pointspr, menuspr);
  489.       }
  490.       if(key[KEYSIX] || (selected==6 && key[key_fire])){   // Quit
  491.      endmenu(snd, pointobj, pointspr, menuspr);
  492.      closingtime();
  493.      quit = TRUE;
  494.       }
  495.       if(key[key_up] && selected>1){                       // Up
  496.      for (i = 0; i < MENUDELTA; i++) {
  497.         moveobjectdelta(pointobj, 0, -MSTEP);
  498.         c = cyclepalette(232, 254, c);
  499.         waitfortick();
  500.         updatescreen();
  501.      }
  502.      selected--;
  503.       }
  504.       if(key[key_down] && selected<6){                     // Down
  505.      for (i = 0; i < MENUDELTA; i++) {
  506.         moveobjectdelta(pointobj, 0, MSTEP);
  507.         c = cyclepalette(232, 254, c);
  508.         waitfortick();
  509.         updatescreen();
  510.      }
  511.      selected++;
  512.       }
  513.    }while(!quit);
  514. }
  515.  
  516.  
  517.  
  518.